package com.gjt.http;

import java.util.Date;
import java.util.Locale;

/**
 * Created with Intel IDEA.
 * 缓存 解析Cache-Control首部（在http 首部中）：防止每次访问这个logo 都去服务器加载一次 ，一般使用get通过http访问的页面可以缓存。
 *      Expires首部（http1.0）:指示可以缓存这个资源表示，直到指定的时间为止；
 *      Cached-control: 他的属性
 *              - max-age=[second]: 从现在起直到缓存项过期之前的秒数
 *              - s-maxage=[second]: 从现在起，直到缓存项在共享缓存中过期之前的秒数，私有缓存可以将缓存项保存更长时间
 *              - public: 可以缓存一个经过认证的响应。否则已经认证的响应不能缓存；
 *              - private: 仅单个用户缓存可以保存响应，而共享缓存不应保存；
 *              - no-cache: 缓存项可以缓存，客户每次访问是要用到一个Etag或Last-modified首部重新验证响应的状态
 *              - no-store: 不缓存
 *      Last-modified首部指示资源最后一次修改日期。客户可以使用一个HEAD请求来检查这个日期。只有本地缓存的副本早于这个日期时，才会真正执行get来的获取资源
 *      Etag首部(1.1): 是资源改变时这个资源的唯一标识符。可以用head请求检查这个标识符，只有本地缓存的副本有一个不同的ETAG时，才会真正执行get来的获取资源
 *      Expires首部和Cached-control都出现Expires首部会被覆盖； 一个首部中可以多个Cached-control只要他们不冲突
 *
 *
 * @Auther: gjt
 * @Date: 2024/3/24 22:47
 */
public class CachedControl {
    private Date max_age = null;
    private Date sMaxage = null;
    private boolean mustRevalidate = false;
    private boolean noCache = false;
    private boolean noStore = false;
    private boolean proxyRevalidate = false;
    private boolean publicCache = false;
    private boolean privateCache =false;

    public CachedControl(String s){
        if(s == null || !s.contains(":")){
            return;
        }
        String value = s.split(":")[1].trim();
        String[] components =value.split(",");

        Date now= new Date();
        for (String component : components) {
            try{
                component = component.trim().toLowerCase(Locale.US);
                if(component.startsWith("max-age")){
                    int i = Integer.parseInt(component.substring(8));
                    max_age = new Date(now.getTime() + 1000 * i);
                }else if(component.startsWith("s-maxage")){
                    int i = Integer.parseInt(component.substring(8));
                    sMaxage = new Date(now.getTime() + 1000*i);
                } else if (component.startsWith("must-revalidate")) {
                    mustRevalidate = true;
                } else if (component.startsWith("proxy-revalidate")) {
                    proxyRevalidate =true;
                } else if (component.startsWith("no-cache")) {
                    noCache = true;
                } else if (component.startsWith("public")) {
                    publicCache = true;
                } else if (component.startsWith("private")) {
                    privateCache = true;
                }
            }catch (RuntimeException e){
                e.printStackTrace();
            }
        }
    }

    public Date getMax_age() {
        return max_age;
    }

    public void setMax_age(Date max_age) {
        this.max_age = max_age;
    }

    public Date getsMaxage() {
        return sMaxage;
    }

    public void setsMaxage(Date sMaxage) {
        this.sMaxage = sMaxage;
    }

    public boolean isMustRevalidate() {
        return mustRevalidate;
    }

    public void setMustRevalidate(boolean mustRevalidate) {
        this.mustRevalidate = mustRevalidate;
    }

    public boolean isNoCache() {
        return noCache;
    }

    public void setNoCache(boolean noCache) {
        this.noCache = noCache;
    }

    public boolean isNoStore() {
        return noStore;
    }

    public void setNoStore(boolean noStore) {
        this.noStore = noStore;
    }

    public boolean isProxyRevalidate() {
        return proxyRevalidate;
    }

    public void setProxyRevalidate(boolean proxyRevalidate) {
        this.proxyRevalidate = proxyRevalidate;
    }

    public boolean isPublicCache() {
        return publicCache;
    }

    public void setPublicCache(boolean publicCache) {
        this.publicCache = publicCache;
    }

    public boolean isPrivateCache() {
        return privateCache;
    }

    public void setPrivateCache(boolean privateCache) {
        this.privateCache = privateCache;
    }

}
